Walkthrough

This PR adds DNS lookup customization and address family configuration capabilities to axios. It introduces type definitions, a new callbackify utility for wrapping async functions, helper predicates for function type detection, HTTP adapter implementation for handling these options, and comprehensive tests with examples.

Changes

Sequence Diagram

sequenceDiagram
    participant Client as User Code
    participant Config as Axios Config
    participant Adapter as HTTP Adapter
    participant Callbackify as Callbackify Helper
    participant LookupFn as Lookup Function
    participant Transport as HTTP/HTTPS Transport

    Client->>Config: Pass config with async lookup function
    Config->>Adapter: Initialize HTTP adapter with config
    Adapter->>Adapter: Destructure lookup and family from config
    alt lookup is async function
        Adapter->>Callbackify: Wrap async lookup with callbackify
        Callbackify->>Callbackify: Check if function is async
        Note over Callbackify: Create callback-style wrapper
    else lookup is sync callback
        Adapter->>Adapter: Use lookup as-is
    end
    Adapter->>LookupFn: Call lookup(hostname, options, callback)
    LookupFn->>LookupFn: Resolve address and family
    LookupFn->>Adapter: Return result via callback
    Adapter->>Adapter: Normalize result to [ip, family] pair
    Adapter->>Transport: Pass lookup and family in request options
    Transport->>Transport: Use custom DNS resolver

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20 minutes

Poem

🐰 A whisker-twitching contribution so fine,
DNS lookups now dance in a queued design,
Async becomes sync through callbackify's spell,
Address families aligned, all working well!
From helpers to adapters, the network takes flight,
Hopping faster with family fourscore and sight! 🌐

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

• 📝 Generate docstrings

lib/utils.js (1)

665-669: Consider renaming the destructured constructor parameter to avoid shadowing the global.

The static analysis tool flags this as shadowing the global constructor property. While the code is functionally correct, renaming improves clarity.

♻️ Suggested refactor

-const [isPlainFunction, isAsyncFn, isGeneratorFn, isAsyncGeneratorFn] = (
-  (...fns) => fns.map(
-    ({constructor})=> (thing) => thing && typeof thing === 'function' && thing.constructor === constructor
-  )
-)(()=> {}, async()=>{}, function*(){}, async function*(){});
+const [isPlainFunction, isAsyncFn, isGeneratorFn, isAsyncGeneratorFn] = (
+  (...fns) => fns.map(
+    ({constructor: ctor}) => (thing) => thing && typeof thing === 'function' && thing.constructor === ctor
+  )
+)(()=> {}, async()=>{}, function*(){}, async function*(){});

lib/helpers/callbackify.js (1)

3-14: Consider adding validation for the callback argument.

If the wrapped function is called without a callback as the last argument, cb will be undefined and the code will throw when attempting to invoke it. This could happen if the function is misused.

🛡️ Defensive validation suggestion

 const callbackify = (fn, reducer) => {
   return utils.isAsyncFn(fn) ? function (...args) {
     const cb = args.pop();
+    if (typeof cb !== 'function') {
+      throw new TypeError('The last argument must be a callback function');
+    }
     fn.apply(this, args).then((value) => {
       try {
         reducer ? cb(null, ...reducer(value)) : cb(null, value);
       } catch (err) {
         cb(err);
       }
     }, cb);
   } : fn;
 }

test/module/typings/esm/index.ts (1)

638-643: The "async" lookup example is not actually asynchronous.

The comment indicates this is an async lookup example, but the function body returns a synchronous array ['127.0.0.1', 4] without async keyword or returning a Promise. To properly demonstrate the async lookup pattern, consider:

✨ Proposed fix to make the example actually async

 // lookup async
 axios.get('/user', {
-  lookup: (hostname: string, opt: object) => {
-    return ['127.0.0.1', 4];
+  lookup: async (hostname: string, opt: object) => {
+    return ['127.0.0.1', 4] as [string, number];
   }
 });

test/unit/adapters/http.js (1)

2131-2136: Consider verifying the hostname parameter passed to the lookup function.

The test verifies that the lookup function is called but doesn't assert that the correct hostname (fake-name.axios) was passed. This could help catch regressions where the hostname isn't properly forwarded.

✨ Suggested enhancement

       let isCalled = false;
+      let receivedHostname = null;

       const {data} = await axios.post(`http://fake-name.axios:4444`, payload,{
         lookup: (hostname, opt, cb) =>  {
           isCalled = true;
+          receivedHostname = hostname;
           cb(null, '127.0.0.1', 4);
         }
       });

       assert.ok(isCalled);
+      assert.strictEqual(receivedHostname, 'fake-name.axios');

       assert.strictEqual(data, payload);

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

_{✏️ Tip: You can disable this entire section by setting review_details to false in your review settings.}